/**
 * ComfyUI 工作流适配器
 * 用于将原始工作流JSON转换为API格式，并处理用户输入参数
 */

// 工作流数据缓存
let designWorkflow: any = null
let designWorkflowAPI: any = null
let currentWorkflowName: string = 'SPA生图（手写提示词）' // 默认工作流

export interface WorkflowAdapterParams {
  prompt: string
  imageName?: string
  referenceImageName?: string
  imageNames?: string[] // 新增：所有图片文件名数组
  style?: string
  business?: string
  feature?: string
  isSmartPrompt?: boolean
  comfyApiKey?: string
  noiseLevel?: string // 新增噪点级别参数
  atmosphere?: string // 新增氛围参数
}

export class WorkflowAdapter {
  constructor() {
    // 初始化时不需要设置私有属性
  }

  // 加载工作流数据
  private async loadWorkflowData() {
    if (!designWorkflow || !designWorkflowAPI) {
      try {
        // 根据当前工作流名称选择对应的工作流文件
        const workflowPath = this.getWorkflowPath(currentWorkflowName)
        
        const workflowResponse = await fetch(workflowPath)
        
        if (!workflowResponse.ok) {
          throw new Error(`工作流文件不存在: ${workflowPath}`)
        }
        
        designWorkflow = await workflowResponse.json()
        designWorkflowAPI = designWorkflow // 使用相同的工作流数据
      } catch (error) {
        console.error('加载工作流数据失败:', error)
        // 使用默认的空工作流
        designWorkflow = {}
        designWorkflowAPI = {}
      }
    }
  }

  // 根据工作流名称获取文件路径
  private getWorkflowPath(workflowName: string): string {
    // 工作流名称到文件路径的映射
    const workflowMap: { [key: string]: string } = {
      // 图片生成相关
      'SPA生图（手写提示词）': '/generate_flow/SPA生图（手写提示词）API.json',
      'SPA生图（风格参考）': '/generate_flow/SPA生图（风格参考）API.json',
      '台球生图（手写提示词）': '/generate_flow/台球生图（手写提示词）API.json',
      '台球生图（风格参考）': '/generate_flow/台球生图（风格参考）API.json',
      '瑜伽生图（手写提示词）': '/generate_flow/瑜伽生图（手写提示词）API.json',
      '瑜伽生图（风格参考）': '/generate_flow/瑜伽生图（风格参考）API.json',
      '健身生图（手写提示词）': '/generate_flow/健身生图（手写提示词）API.json',
      '健身生图（风格参考）': '/generate_flow/健身生图（风格参考）API.json',
      
      // 图片编辑相关
      '单图指令编辑': '/edit_flow/单图指令编辑API.json',
      '双图指令编辑': '/edit_flow/双图指令编辑API.json',
      '双图编辑参考风格': '/edit_flow/双图编辑参考风格API.json',
      '光线氛围': '/edit_flow/光线氛围API.json',
      
      // 高清放大相关
      '高清放大（gemini）': '/magnify_flow/高清放大API.json',
      '高清放大': '/magnify_flow/高清放大API.json',
      
      // 图像迁移相关
      '图像迁移': '/migration_flow/图像迁移API.json',
      
      // 视频生成相关
      '图生视频': '/video_flow/图生视频API.json'
    }
    
    const path = workflowMap[workflowName]
    if (!path) {
      console.warn(`未找到工作流映射: ${workflowName}，使用默认路径`)
      return `/generate_flow/瑜伽生图（手写提示词）API.json`
    }
    
    return path
  }


  // 设置业务类型（从外部调用）
  setBusinessType(business: string, feature: string, isSmartPrompt: boolean = false): void {
    // 根据功能类型选择对应的工作流
    let workflowName = '';
    
    // 根据功能类型选择工作流
    switch (feature) {
      case '高清放大':
        workflowName = '高清放大';
        break;
      case '图像迁移':
        workflowName = '图像迁移';
        break;
      case '视频生成':
        workflowName = '图生视频';
        break;
      case '图片编辑':
        // 图片编辑功能，根据具体子功能选择
        workflowName = '单图指令编辑'; // 默认使用单图编辑
        break;
      case '单图指令编辑':
        workflowName = '单图指令编辑';
        break;
      case '双图编辑参考风格':
        workflowName = '双图编辑参考风格';
        break;
      case '双图指令编辑':
        workflowName = '双图指令编辑';
        break;
      case '光线氛围':
        workflowName = '光线氛围';
        break;
      case '草图（白模生图）':
        workflowName = '单图指令编辑';
        break;
      case '风格参考生图':
        workflowName = '双图编辑参考风格';
        break;
      case '手写提示词':
        // 手写提示词模式，根据业务类型选择
        if (business === 'SPA') {
          workflowName = 'SPA生图（手写提示词）';
        } else if (business === '台球') {
          workflowName = '台球生图（手写提示词）';
        } else if (business === '瑜伽') {
          workflowName = '瑜伽生图（手写提示词）';
        } else if (business === '健身房') {
          workflowName = '健身生图（手写提示词）';
        } else {
          // 默认使用瑜伽工作流
          workflowName = '瑜伽生图（手写提示词）';
        }
        break;
      case '风格参考':
        // 风格参考模式，根据业务类型选择
        if (business === 'SPA') {
          workflowName = 'SPA生图（风格参考）';
        } else if (business === '台球') {
          workflowName = '台球生图（风格参考）';
        } else if (business === '瑜伽') {
          workflowName = '瑜伽生图（风格参考）';
        } else if (business === '健身房') {
          workflowName = '健身生图（风格参考）';
        } else {
          // 默认使用瑜伽工作流
          workflowName = '瑜伽生图（风格参考）';
        }
        break;
      case '图片生成':
      default:
        // 默认图片生成功能，根据业务类型和智能提示词状态选择
        if (business === 'SPA') {
          workflowName = isSmartPrompt ? 'SPA生图（手写提示词）' : 'SPA生图（风格参考）';
        } else if (business === '台球') {
          workflowName = isSmartPrompt ? '台球生图（手写提示词）' : '台球生图（风格参考）';
        } else if (business === '瑜伽') {
          workflowName = isSmartPrompt ? '瑜伽生图（手写提示词）' : '瑜伽生图（风格参考）';
        } else if (business === '健身房') {
          workflowName = isSmartPrompt ? '健身生图（手写提示词）' : '健身生图（风格参考）';
        } else {
          // 默认使用瑜伽工作流
          workflowName = isSmartPrompt ? '瑜伽生图（手写提示词）' : '瑜伽生图（风格参考）';
        }
        break;
    }
    
    // 更新当前工作流名称
    currentWorkflowName = workflowName;
    
    // 重置缓存，强制重新加载新的工作流
    designWorkflow = null;
    designWorkflowAPI = null;
    
    console.log(`工作流已切换到: ${workflowName}`);
  }

  /**
   * 创建API格式的工作流
   * @param params 用户输入参数
   */
  async createAPIWorkflow(params: WorkflowAdapterParams): Promise<any> {
    try {
      // 确保工作流数据已加载
      await this.loadWorkflowData()
      
      // 深拷贝API工作流模板
      const workflow = JSON.parse(JSON.stringify(designWorkflowAPI))
      
      // 根据参数类型进行不同的处理
      if (params.feature === '高清放大') {
        return this.createUpscaleWorkflow(workflow, params)
      } else if (params.feature === '草图（白模生图）') {
        return this.createSketchWorkflow(workflow, params)
      } else if (params.feature === '风格参考生图') {
        return this.createStyleReferenceWorkflow(workflow, params)
      } else if (params.feature === '光线氛围') {
        return this.createAtmosphereWorkflow(workflow, params)
      } else if (params.feature === '图像迁移') {
        return this.createMigrationWorkflow(workflow, params)
      } else if (params.feature === '双图指令编辑') {
        return this.createDoubleEditWorkflow(workflow, params)
      } else if (params.feature === '单图指令编辑') {
        return this.createSingleEditWorkflow(workflow, params)
      } else if (params.feature === '双图编辑参考风格') {
        return this.createStyleReferenceWorkflow(workflow, params)
      } else {
        // 默认图片生成工作流
        return this.createImageGenerationWorkflow(workflow, params)
      }
    } catch (error) {
      console.error('创建工作流失败:', error)
      throw error
    }
  }

  /**
   * 创建高清放大工作流
   */
  private createUpscaleWorkflow(workflow: any, params: WorkflowAdapterParams): any {
    console.log('创建高清放大工作流，参数:', params)
    
    // 高清放大工作流主要处理图片加载节点和噪点参数
    Object.keys(workflow).forEach(nodeId => {
      const node = workflow[nodeId]
      
      // 查找图片加载节点并替换图片名称
      if (node.class_type === 'LoadImage' && params.imageNames && params.imageNames.length >= 1) {
        node.inputs.image = params.imageNames[0]
        console.log(`更新图片节点${nodeId}的图片参数为:`, params.imageNames[0])
      }
      
      // 处理噪点参数 - 只更新基本调度器的denoise参数
      if (params.noiseLevel && node.class_type === 'BasicScheduler') {
        const noiseValue = parseFloat(params.noiseLevel)
        node.inputs.denoise = noiseValue
        console.log(`更新节点${nodeId}的denoise参数为:`, noiseValue)
      }
    })
    
    return workflow
  }

  /**
   * 创建图片生成工作流
   */
  private createImageGenerationWorkflow(workflow: any, params: WorkflowAdapterParams): any {
    console.log('创建图片生成工作流，参数:', params)
    
    // 动态查找智能提示词相关节点
    let templateNodeId: string | null = null;
    let finalPromptNodeId: string | null = null;
    
    // 查找模板节点（包含 "Style: <<" 的 easy showAnything 节点）
    Object.keys(workflow).forEach(nodeId => {
      const node = workflow[nodeId];
      if (node.class_type === 'easy showAnything' && 
          node.inputs.text && 
          node.inputs.text.includes('Style: <<')) {
        templateNodeId = nodeId;
      }
    });
    
    // 查找最终提示词节点（包含具体描述文本的 easy showAnything 节点）
    Object.keys(workflow).forEach(nodeId => {
      const node = workflow[nodeId];
      if (node.class_type === 'easy showAnything' && 
          node.inputs.text && 
          node.inputs.text.length > 200 && // 最终提示词通常比较长
          !node.inputs.text.includes('Style: <<')) {
        finalPromptNodeId = nodeId;
      }
    });
    
    console.log('找到的智能提示词节点:', { templateNodeId, finalPromptNodeId });
    
    Object.keys(workflow).forEach(nodeId => {
      const node = workflow[nodeId]
      
      // 处理智能提示词模板节点
      if (nodeId === templateNodeId && node.class_type === 'easy showAnything') {
        if (params.isSmartPrompt) {
          // 智能提示词模式：构建模板文本
          const templateParts = [];
          if (params.prompt.includes('风格：')) {
            const styleMatch = params.prompt.match(/风格：([^，]+)/);
            if (styleMatch) {
              templateParts.push(`Style: <<${styleMatch[1]}>>`);
            }
          }
          if (params.prompt.includes('色调：')) {
            const colorMatch = params.prompt.match(/色调：([^，]+)/);
            if (colorMatch) {
              templateParts.push(`Tone: <<${colorMatch[1]}>>`);
            }
          }
          if (params.prompt.includes('固定内容：')) {
            const contentMatch = params.prompt.match(/固定内容：([^，]+)/);
            if (contentMatch) {
              templateParts.push(`Fixed Elements (always including these materials or colors): <<${contentMatch[1]}>>`);
            }
          }
          node.inputs.text = templateParts.join(', ');
        } else {
          // 普通提示词模式：保持原有模板不变
          // node.inputs.text 保持不变
        }
      }
      
      // 处理最终提示词节点
      if (nodeId === finalPromptNodeId && node.class_type === 'easy showAnything') {
        if (params.isSmartPrompt) {
          // 智能提示词模式：使用组合后的提示词
          node.inputs.text = params.prompt;
        } else {
          // 普通提示词模式：直接使用用户输入的提示词
          node.inputs.text = params.prompt;
        }
      }
      
      // 查找文本编码节点并替换提示词
      if (node.class_type === 'CLIPTextEncode' && node.inputs.text) {
        // 对于手写提示词模式，替换所有CLIPTextEncode节点的文本
        if (currentWorkflowName.includes('手写提示词')) {
          node.inputs.text = params.prompt
          console.log(`更新手写提示词节点${nodeId}的文本为:`, params.prompt)
        } else {
          // 对于智能提示词模式，只替换非智能提示词节点的文本
          if (nodeId !== templateNodeId && nodeId !== finalPromptNodeId) {
            node.inputs.text = params.prompt
            console.log(`更新智能提示词节点${nodeId}的文本为:`, params.prompt)
          }
        }
      }
      
      // 查找图片加载节点并替换图片名称
      if (node.class_type === 'LoadImage' && node.inputs.image) {
        // 检查是否是风格参考模式（有参考图的情况）
        if (params.imageNames && params.imageNames.length >= 2 && currentWorkflowName.includes('风格参考')) {
          // 风格参考模式：需要处理两张图片
          // 根据不同业态的工作流文件，节点ID不同：
          // SPA生图（风格参考）：节点164(参考图), 165(原图)
          // 瑜伽生图（风格参考）：节点374(参考图), 375(原图)
          // 台球生图（风格参考）：节点51(参考图), 52(原图)
          // 健身生图（风格参考）：节点49(参考图), 50(原图)
          
          // 根据当前工作流名称确定节点ID
          let referenceNodeId: string, originalNodeId: string;
          
          if (currentWorkflowName.includes('SPA')) {
            referenceNodeId = '164';  // 参考图
            originalNodeId = '165';   // 原图
          } else if (currentWorkflowName.includes('瑜伽')) {
            referenceNodeId = '374';  // 参考图
            originalNodeId = '375';  // 原图
          } else if (currentWorkflowName.includes('台球')) {
            referenceNodeId = '51';   // 参考图
            originalNodeId = '52';   // 原图
          } else if (currentWorkflowName.includes('健身')) {
            referenceNodeId = '49';  // 参考图
            originalNodeId = '50';   // 原图
          } else {
            // 默认情况，按顺序分配
            referenceNodeId = '164';
            originalNodeId = '165';
          }
          
          if (nodeId === referenceNodeId) {
            // 参考图节点：用户上传的第二张图片（参考图）
            node.inputs.image = params.imageNames[1]
            console.log(`更新参考图节点${nodeId}的图片参数为:`, params.imageNames[1])
          } else if (nodeId === originalNodeId) {
            // 原图节点：用户上传的第一张图片（原图）
            node.inputs.image = params.imageNames[0]
            console.log(`更新原图节点${nodeId}的图片参数为:`, params.imageNames[0])
          }
        } else if (params.imageNames && params.imageNames.length >= 1) {
          // 手写提示词模式：只需要一张图片
          node.inputs.image = params.imageNames[0]
          console.log(`更新图片节点${nodeId}的图片参数为:`, params.imageNames[0])
        }
      }
    })
    
    return workflow
  }

  /**
   * 创建草图（白模生图）工作流
   */
  private createSketchWorkflow(workflow: any, params: WorkflowAdapterParams): any {
    console.log('创建草图工作流，参数:', params)
    
    // 草图生图通常需要ControlNet
    // 这里需要根据您的ControlNet节点来调整
    
    Object.keys(workflow).forEach(nodeId => {
      const node = workflow[nodeId]
      
      if (node.class_type === 'CLIPTextEncode' && node.inputs.text) {
        node.inputs.text = `sketch, ${params.prompt}, architectural drawing, line art`
      }
      
      if (node.class_type === 'LoadImage' && params.imageNames && params.imageNames.length >= 1) {
        node.inputs.image = params.imageNames[0]
        console.log(`更新图片节点${nodeId}的图片参数为:`, params.imageNames[0])
      }
    })
    
    return workflow
  }

  /**
   * 创建风格参考生图工作流
   */
  private createStyleReferenceWorkflow(workflow: any, params: WorkflowAdapterParams): any {
    console.log('=== 创建风格参考工作流开始 ===')
    console.log('工作流参数:', params)
    console.log('当前工作流名称:', currentWorkflowName)
    console.log('imageName:', params.imageName)
    console.log('referenceImageName:', params.referenceImageName)
    console.log('imageNames数组:', params.imageNames)
    
    // 风格参考需要两张图片：原图和参考图
    // 需要根据节点ID来区分不同的图片加载节点
    let imageNodeCount = 0;
    
    Object.keys(workflow).forEach(nodeId => {
      const node = workflow[nodeId]
      
      if (node.class_type === 'CLIPTextEncode' && node.inputs.text) {
        node.inputs.text = `${params.prompt}, style reference`
        console.log(`更新CLIPTextEncode节点${nodeId}的提示词`)
      }
      
      // 处理LoadImage节点 - 根据节点ID和图片名称来区分原图和参考图
      if (node.class_type === 'LoadImage' && node.inputs.image) {
        imageNodeCount++;
        console.log(`\n--- 处理LoadImage节点${nodeId} (第${imageNodeCount}个图片节点) ---`)
        console.log('原始图片:', node.inputs.image)
        
        // 使用 switch case 更直观地处理不同节点
        switch (nodeId) {
          case '14':
            // 节点14: 参考图节点，使用第二张图片（参考图）
            if (params.imageNames && params.imageNames.length >= 2) {
              node.inputs.image = params.imageNames[1]
              console.log(`✅ 更新参考图节点${nodeId}的图片参数为:`, params.imageNames[1])
            } else {
              console.log(`❌ 节点${nodeId}缺少参考图，imageNames长度:`, params.imageNames?.length)
            }
            break;
            
          case '15':
            // 节点15: 原图节点，使用第一张图片（原图）
            if (params.imageNames && params.imageNames.length >= 1) {
              node.inputs.image = params.imageNames[0]
              console.log(`✅ 更新原图节点${nodeId}的图片参数为:`, params.imageNames[0])
            } else {
              console.log(`❌ 节点${nodeId}缺少原图，imageNames长度:`, params.imageNames?.length)
            }
            break;
            
          default:
            // 其他节点按顺序分配
            if (imageNodeCount === 1 && params.imageNames && params.imageNames.length >= 1) {
              node.inputs.image = params.imageNames[0]
              console.log(`✅ 更新第一个图片节点${nodeId}的图片参数为:`, params.imageNames[0])
            } else if (imageNodeCount === 2 && params.imageNames && params.imageNames.length >= 2) {
              node.inputs.image = params.imageNames[1]
              console.log(`✅ 更新第二个图片节点${nodeId}的图片参数为:`, params.imageNames[1])
            } else {
              console.log(`❌ 节点${nodeId}无法分配图片，imageNames长度:`, params.imageNames?.length)
            }
            break;
        }
        
        console.log('最终图片:', node.inputs.image)
      }
    })
    
    console.log('=== 创建风格参考工作流结束 ===')
    return workflow
  }

  /**
   * 创建光线氛围工作流
   */
  private createAtmosphereWorkflow(workflow: any, params: WorkflowAdapterParams): any {
    console.log('创建光线氛围工作流，参数:', params)
    
    Object.keys(workflow).forEach(nodeId => {
      const node = workflow[nodeId]
      
      // 查找氛围选择器节点并替换氛围参数
      if (node.class_type === 'AmbienceSelector' && params.atmosphere) {
        node.inputs.氛围 = params.atmosphere
        console.log(`更新节点${nodeId}的氛围参数为:`, params.atmosphere)
      }
      
      // 查找图片加载节点并替换图片名称
      if (node.class_type === 'LoadImage' && params.imageNames && params.imageNames.length >= 1) {
        node.inputs.image = params.imageNames[0]
        console.log(`更新节点${nodeId}的图片参数为:`, params.imageNames[0])
      }
    })
    
    return workflow
  }

  /**
   * 创建图像迁移工作流
   */
  private createMigrationWorkflow(workflow: any, params: WorkflowAdapterParams): any {
    console.log('创建图像迁移工作流，参数:', params)
    
    Object.keys(workflow).forEach(nodeId => {
      const node = workflow[nodeId]
      
      // 查找图片加载节点并替换图片名称
      if (node.class_type === 'LoadImage' && params.imageNames && params.imageNames.length >= 1) {
        node.inputs.image = params.imageNames[0]
        console.log(`更新节点${nodeId}的图片参数为:`, params.imageNames[0])
      }
      
      // 查找CLIP文本编码节点并替换提示词
      if (node.class_type === 'CLIPTextEncode' && params.prompt) {
        node.inputs.text = params.prompt
        console.log(`更新节点${nodeId}的提示词为:`, params.prompt)
      }
      
      // 特殊处理：对于图像迁移工作流，我们需要处理遮罩相关的节点
      // 节点53和54是固定的遮罩图片，我们需要使用涂抹后的图片替换它们
      if (nodeId === '53' || nodeId === '54') {
        // 使用涂抹后的图片作为遮罩
        if (params.imageNames && params.imageNames.length >= 1) {
          node.inputs.image = params.imageNames[0]
          console.log(`更新遮罩节点${nodeId}的图片参数为:`, params.imageNames[0])
        }
      }
    })
    
    return workflow
  }

  /**
   * 创建双图指令编辑工作流
   */
  private createDoubleEditWorkflow(workflow: any, params: WorkflowAdapterParams): any {
    console.log('=== 创建双图指令编辑工作流开始 ===')
    console.log('工作流参数:', params)
    console.log('imageNames数组:', params.imageNames)
    
    // 双图指令编辑需要两张图片：原图和参考图，以及指令提示词
    let imageNodeCount = 0;
    
    Object.keys(workflow).forEach(nodeId => {
      const node = workflow[nodeId]
      
      // 处理指令节点 - 双图指令编辑使用 easy showAnything 节点
      if (node.class_type === 'easy showAnything' && node.inputs.text) {
        node.inputs.text = params.prompt
        console.log(`更新指令节点${nodeId}的提示词为:`, params.prompt)
      }
      
      // 处理CLIPTextEncode节点（如果有的话）
      if (node.class_type === 'CLIPTextEncode' && node.inputs.text) {
        node.inputs.text = params.prompt
        console.log(`更新CLIPTextEncode节点${nodeId}的提示词为:`, params.prompt)
      }
      
      // 处理LoadImage节点 - 使用 switch case 更直观地处理不同节点
      if (node.class_type === 'LoadImage' && node.inputs.image) {
        imageNodeCount++;
        console.log(`\n--- 处理LoadImage节点${nodeId} (第${imageNodeCount}个图片节点) ---`)
        console.log('原始图片:', node.inputs.image)
        
        switch (nodeId) {
          case '14':
            // 节点14: 参考图节点，使用第二张图片（参考图）
            if (params.imageNames && params.imageNames.length >= 2) {
              node.inputs.image = params.imageNames[1]
              console.log(`✅ 更新参考图节点${nodeId}的图片参数为:`, params.imageNames[1])
            } else {
              console.log(`❌ 节点${nodeId}缺少参考图，imageNames长度:`, params.imageNames?.length)
            }
            break;
            
          case '15':
            // 节点15: 原图节点，使用第一张图片（原图）
            if (params.imageNames && params.imageNames.length >= 1) {
              node.inputs.image = params.imageNames[0]
              console.log(`✅ 更新原图节点${nodeId}的图片参数为:`, params.imageNames[0])
            } else {
              console.log(`❌ 节点${nodeId}缺少原图，imageNames长度:`, params.imageNames?.length)
            }
            break;
            
          default:
            // 其他节点按顺序分配
            if (imageNodeCount === 1 && params.imageNames && params.imageNames.length >= 1) {
              node.inputs.image = params.imageNames[0]
              console.log(`✅ 更新第一个图片节点${nodeId}的图片参数为:`, params.imageNames[0])
            } else if (imageNodeCount === 2 && params.imageNames && params.imageNames.length >= 2) {
              node.inputs.image = params.imageNames[1]
              console.log(`✅ 更新第二个图片节点${nodeId}的图片参数为:`, params.imageNames[1])
            } else {
              console.log(`❌ 节点${nodeId}无法分配图片，imageNames长度:`, params.imageNames?.length)
            }
            break;
        }
        
        console.log('最终图片:', node.inputs.image)
      }
    })
    
    console.log('=== 创建双图指令编辑工作流结束 ===')
    return workflow
  }

  /**
   * 创建单图指令编辑工作流
   */
  private createSingleEditWorkflow(workflow: any, params: WorkflowAdapterParams): any {
    console.log('创建单图指令编辑工作流，参数:', params)
    
    // 单图指令编辑需要一张图片和指令提示词
    Object.keys(workflow).forEach(nodeId => {
      const node = workflow[nodeId]
      
      // 处理指令节点 - 单图指令编辑使用 easy showAnything 节点
      if (node.class_type === 'easy showAnything' && node.inputs.text) {
        node.inputs.text = params.prompt
        console.log(`更新指令节点${nodeId}的提示词为:`, params.prompt)
      }
      
      // 处理CLIPTextEncode节点（如果有的话）
      if (node.class_type === 'CLIPTextEncode' && node.inputs.text) {
        node.inputs.text = params.prompt
        console.log(`更新CLIPTextEncode节点${nodeId}的提示词为:`, params.prompt)
      }
      
      // 处理LoadImage节点 - 单图指令编辑只需要一张图片
      if (node.class_type === 'LoadImage' && node.inputs.image && params.imageNames && params.imageNames.length >= 1) {
        node.inputs.image = params.imageNames[0]
        console.log(`更新图片节点${nodeId}的图片参数为:`, params.imageNames[0])
      }
    })
    
    return workflow
  }

  /**
   * 根据业务类型调整工作流参数
   */


  /**
   * 获取工作流信息
   */
  getWorkflowInfo(): any {
    return {
      name: '设计部工作流V2.6',
      version: '2.6',
      description: '支持图片生成、草图生图、风格参考、高清放大等功能',
      supportedFeatures: [
        '图片生成',
        '手写提示词',
        '风格参考',
        '视频生成',
        '图像迁移',
        '单图指令编辑',
        '双图编辑参考风格',
        '双图指令编辑',
        '光线氛围',
        '草图（白模生图）',
        '风格参考生图',
        '高清放大'
      ],
      supportedBusiness: [
        '瑜伽',
        'SPA',
        '台球'
      ]
    }
  }

  /**
   * 验证工作流参数
   */
  validateParams(params: WorkflowAdapterParams): { valid: boolean; errors: string[] } {
    const errors: string[] = []
    
    // 不需要提示词的模式
    const noPromptFeatures = [
      '高清放大',
      '图像迁移', 
      '风格参考',
      '双图编辑参考风格',
      '光线氛围'
    ]
    
    // 只有需要提示词的模式才进行提示词验证
    if (!noPromptFeatures.includes(params.feature || '')) {
      if (!params.prompt || params.prompt.trim().length === 0) {
        errors.push('提示词不能为空')
      }
      
      if (params.prompt && params.prompt.length > 500) {
        errors.push('提示词长度不能超过500个字符')
      }
    }
    
    if (params.feature === '草图（白模生图）' && (!params.imageNames || params.imageNames.length < 1)) {
      errors.push('草图生图需要上传原图')
    }
    
    if (params.feature === '风格参考生图' && (!params.imageNames || params.imageNames.length < 2)) {
      errors.push('风格参考生图需要上传原图和参考图')
    }
    
    // 高清放大需要上传原图
    if (params.feature === '高清放大' && (!params.imageNames || params.imageNames.length < 1)) {
      errors.push('高清放大需要上传原图')
    }
    
    // 图像迁移需要上传原图
    if (params.feature === '图像迁移' && (!params.imageNames || params.imageNames.length < 1)) {
      errors.push('图像迁移需要上传原图')
    }
    
    // 风格参考需要上传参考图
    if (params.feature === '风格参考' && (!params.imageNames || params.imageNames.length < 2)) {
      errors.push('风格参考需要上传参考图')
    }
    
    // 双图编辑参考风格需要上传两张图片
    if (params.feature === '双图编辑参考风格' && (!params.imageNames || params.imageNames.length < 2)) {
      errors.push('双图编辑参考风格需要上传原图和参考图')
    }
    
    // 光线氛围需要上传原图并选择氛围
    if (params.feature === '光线氛围') {
      if (!params.imageNames || params.imageNames.length < 1) {
        errors.push('光线氛围需要上传原图')
      }
      if (!params.atmosphere) {
        errors.push('光线氛围需要选择氛围')
      }
    }
    
    return {
      valid: errors.length === 0,
      errors
    }
  }

  // 获取当前工作流名称
  getCurrentWorkflowName(): string {
    return currentWorkflowName
  }

  // 获取当前工作流信息（包括名称和路径）
  getCurrentWorkflowInfo(): { name: string; path: string } {
    return {
      name: currentWorkflowName,
      path: this.getWorkflowPath(currentWorkflowName)
    }
  }
}

// 创建单例实例
export const workflowAdapter = new WorkflowAdapter()
